home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / glass / glass.lha / GLASS / tm / tmtplelm.c < prev    next >
C/C++ Source or Header  |  1990-11-06  |  14KB  |  586 lines
  1. /* 
  2.    Copyright (C) 1990 C van Reewijk, email: dutentb.uucp!reeuwijk
  3.  
  4. This file is part of GLASS.
  5.  
  6. GLASS is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 1, or (at your option)
  9. any later version.
  10.  
  11. GLASS is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GLASS; see the file COPYING.  If not, write to
  18. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. /* file: tmtplelm.c
  21.  
  22.    template file:      tmtplelm.ct
  23.    datastructure file: tplelm.ds
  24.    tm version:         27 (Mon Sep 10 17:30:58 METDST 1990)
  25.  */
  26.  
  27. /* Standard UNIX libraries */
  28. #include <stdio.h>
  29.  
  30. /* Standard tm library */
  31. #include <tmc.h>
  32.  
  33. /* Local definitions */
  34. #include "tmdefs.h"
  35.  
  36. #include "debug.h"
  37. #include "tmtplelm.h"
  38. #include "tmds.h"
  39. #include "tmstring.h"
  40. #include "tmglobal.h"
  41.  
  42. /* ---- start of /users/reeuwijk/esprit/lib/cllu.ct ---- */
  43.  
  44. /* routines for tplelm.
  45.  
  46.    template file:      /users/reeuwijk/esprit/lib/cllu.ct
  47.    datastructure file: tplelm.ds
  48.    tm version:         27 (Mon Sep 10 17:30:58 METDST 1990)
  49.  
  50.    The following C pre-processor variables may be defined:
  51.    STAT          If you want code for statistics.
  52.          Statistics are written to 'FILE *statstream'.
  53.    FATAL(msg)    If you want supply a fatal error handler to print 'msg'.
  54.          A default is provided.
  55.   
  56.    Possible declaration or #define'ing of statstream
  57.    must be done outside this module.
  58.  */
  59.  
  60. #ifndef WORDBUFSIZE
  61. #define WORDBUFSIZE 100
  62. #endif
  63.  
  64. #ifdef STAT
  65. static char tm_allocfreed[] = "%-15s: %6ld allocated, %6ld freed.%s\n";
  66. #endif
  67.  
  68. static char *tm_srcfile = __FILE__;
  69.  
  70. #ifndef FATAL
  71. #define FATAL(msg) tmfatal(tm_srcfile,__LINE__,msg)
  72. #endif
  73.  
  74. /* the possible error messages */
  75. static char tm_outofmemory[] = "out of memory";
  76. static char tm_nilptr[] = "NIL pointer";
  77.  
  78.  
  79. #ifndef FATALTAG
  80. #define FATALTAG(tg) tmbadtag(tm_srcfile,__LINE__,tg)
  81. #endif
  82.  
  83. #ifdef STAT
  84. static long int newcnt_Plain = 0, frecnt_Plain = 0;
  85. static long int newcnt_Foreach = 0, frecnt_Foreach = 0;
  86. static long int newcnt_While = 0, frecnt_While = 0;
  87. static long int newcnt_If = 0, frecnt_If = 0;
  88. static long int newcnt_Set = 0, frecnt_Set = 0;
  89. static long int newcnt_Append = 0, frecnt_Append = 0;
  90. static long int newcnt_Error = 0, frecnt_Error = 0;
  91. static long int newcnt_Exit = 0, frecnt_Exit = 0;
  92. static long int newcnt_Include = 0, frecnt_Include = 0;
  93. static long int newcnt_Copy = 0, frecnt_Copy = 0;
  94. static long int newcnt_Insert = 0, frecnt_Insert = 0;
  95. #endif
  96.  
  97. /************************************************
  98.  *    new_<cons> and new_<tuple> routines       *
  99.  ************************************************/
  100.  
  101. #if defined(__STDC__) && __STDC__>0
  102. #endif
  103.  
  104. /* Allocate a new instance of constructor 'Plain' */
  105. tplelm new_Plain( p_lno, p_plainline )
  106.  int p_lno;
  107.  string p_plainline;
  108. {
  109.     register tplelm new;
  110.  
  111.     new = (tplelm) malloc( sizeof(*new) );
  112.     if( (char *)new == (char *)0 ){
  113.     FATAL( tm_outofmemory );
  114.     }
  115.     new->next = tplelmNIL;
  116.     new->tag = TAGPlain;
  117.     new->Plain.lno = p_lno;
  118.     new->Plain.plainline = p_plainline;
  119. #ifdef STAT
  120.     newcnt_Plain++;
  121. #endif
  122.     return (tplelm) new;
  123. }
  124.  
  125. /* Allocate a new instance of constructor 'Foreach' */
  126. tplelm new_Foreach( p_lno, p_felist, p_felines )
  127.  int p_lno;
  128.  string p_felist;
  129.  tplelm_list p_felines;
  130. {
  131.     register tplelm new;
  132.  
  133.     new = (tplelm) malloc( sizeof(*new) );
  134.     if( (char *)new == (char *)0 ){
  135.     FATAL( tm_outofmemory );
  136.     }
  137.     new->next = tplelmNIL;
  138.     new->tag = TAGForeach;
  139.     new->Foreach.lno = p_lno;
  140.     new->Foreach.felist = p_felist;
  141.     new->Foreach.felines = p_felines;
  142. #ifdef STAT
  143.     newcnt_Foreach++;
  144. #endif
  145.     return (tplelm) new;
  146. }
  147.  
  148. /* Allocate a new instance of constructor 'While' */
  149. tplelm new_While( p_lno, p_whilecond, p_whilelines )
  150.  int p_lno;
  151.  string p_whilecond;
  152.  tplelm_list p_whilelines;
  153. {
  154.     register tplelm new;
  155.  
  156.     new = (tplelm) malloc( sizeof(*new) );
  157.     if( (char *)new == (char *)0 ){
  158.     FATAL( tm_outofmemory );
  159.     }
  160.     new->next = tplelmNIL;
  161.     new->tag = TAGWhile;
  162.     new->While.lno = p_lno;
  163.     new->While.whilecond = p_whilecond;
  164.     new->While.whilelines = p_whilelines;
  165. #ifdef STAT
  166.     newcnt_While++;
  167. #endif
  168.     return (tplelm) new;
  169. }
  170.  
  171. /* Allocate a new instance of constructor 'If' */
  172. tplelm new_If( p_lno, p_ifcond, p_ifthen, p_ifelse )
  173.  int p_lno;
  174.  string p_ifcond;
  175.  tplelm_list p_ifthen;
  176.  tplelm_list p_ifelse;
  177. {
  178.     register tplelm new;
  179.  
  180.     new = (tplelm) malloc( sizeof(*new) );
  181.     if( (char *)new == (char *)0 ){
  182.     FATAL( tm_outofmemory );
  183.     }
  184.     new->next = tplelmNIL;
  185.     new->tag = TAGIf;
  186.     new->If.lno = p_lno;
  187.     new->If.ifcond = p_ifcond;
  188.     new->If.ifthen = p_ifthen;
  189.     new->If.ifelse = p_ifelse;
  190. #ifdef STAT
  191.     newcnt_If++;
  192. #endif
  193.     return (tplelm) new;
  194. }
  195.  
  196. /* Allocate a new instance of constructor 'Set' */
  197. tplelm new_Set( p_lno, p_setline )
  198.  int p_lno;
  199.  string p_setline;
  200. {
  201.     register tplelm new;
  202.  
  203.     new = (tplelm) malloc( sizeof(*new) );
  204.     if( (char *)new == (char *)0 ){
  205.     FATAL( tm_outofmemory );
  206.     }
  207.     new->next = tplelmNIL;
  208.     new->tag = TAGSet;
  209.     new->Set.lno = p_lno;
  210.     new->Set.setline = p_setline;
  211. #ifdef STAT
  212.     newcnt_Set++;
  213. #endif
  214.     return (tplelm) new;
  215. }
  216.  
  217. /* Allocate a new instance of constructor 'Append' */
  218. tplelm new_Append( p_lno, p_appline )
  219.  int p_lno;
  220.  string p_appline;
  221. {
  222.     register tplelm new;
  223.  
  224.     new = (tplelm) malloc( sizeof(*new) );
  225.     if( (char *)new == (char *)0 ){
  226.     FATAL( tm_outofmemory );
  227.     }
  228.     new->next = tplelmNIL;
  229.     new->tag = TAGAppend;
  230.     new->Append.lno = p_lno;
  231.     new->Append.appline = p_appline;
  232. #ifdef STAT
  233.     newcnt_Append++;
  234. #endif
  235.     return (tplelm) new;
  236. }
  237.  
  238. /* Allocate a new instance of constructor 'Error' */
  239. tplelm new_Error( p_lno, p_errstr )
  240.  int p_lno;
  241.  string p_errstr;
  242. {
  243.     register tplelm new;
  244.  
  245.     new = (tplelm) malloc( sizeof(*new) );
  246.     if( (char *)new == (char *)0 ){
  247.     FATAL( tm_outofmemory );
  248.     }
  249.     new->next = tplelmNIL;
  250.     new->tag = TAGError;
  251.     new->Error.lno = p_lno;
  252.     new->Error.errstr = p_errstr;
  253. #ifdef STAT
  254.     newcnt_Error++;
  255. #endif
  256.     return (tplelm) new;
  257. }
  258.  
  259. /* Allocate a new instance of constructor 'Exit' */
  260. tplelm new_Exit( p_lno, p_str )
  261.  int p_lno;
  262.  string p_str;
  263. {
  264.     register tplelm new;
  265.  
  266.     new = (tplelm) malloc( sizeof(*new) );
  267.     if( (char *)new == (char *)0 ){
  268.     FATAL( tm_outofmemory );
  269.     }
  270.     new->next = tplelmNIL;
  271.     new->tag = TAGExit;
  272.     new->Exit.lno = p_lno;
  273.     new->Exit.str = p_str;
  274. #ifdef STAT
  275.     newcnt_Exit++;
  276. #endif
  277.     return (tplelm) new;
  278. }
  279.  
  280. /* Allocate a new instance of constructor 'Include' */
  281. tplelm new_Include( p_lno, p_fname )
  282.  int p_lno;
  283.  string p_fname;
  284. {
  285.     register tplelm new;
  286.  
  287.     new = (tplelm) malloc( sizeof(*new) );
  288.     if( (char *)new == (char *)0 ){
  289.     FATAL( tm_outofmemory );
  290.     }
  291.     new->next = tplelmNIL;
  292.     new->tag = TAGInclude;
  293.     new->Include.lno = p_lno;
  294.     new->Include.fname = p_fname;
  295. #ifdef STAT
  296.     newcnt_Include++;
  297. #endif
  298.     return (tplelm) new;
  299. }
  300.  
  301. /* Allocate a new instance of constructor 'Copy' */
  302. tplelm new_Copy( p_lno, p_fname )
  303.  int p_lno;
  304.  string p_fname;
  305. {
  306.     register tplelm new;
  307.  
  308.     new = (tplelm) malloc( sizeof(*new) );
  309.     if( (char *)new == (char *)0 ){
  310.     FATAL( tm_outofmemory );
  311.     }
  312.     new->next = tplelmNIL;
  313.     new->tag = TAGCopy;
  314.     new->Copy.lno = p_lno;
  315.     new->Copy.fname = p_fname;
  316. #ifdef STAT
  317.     newcnt_Copy++;
  318. #endif
  319.     return (tplelm) new;
  320. }
  321.  
  322. /* Allocate a new instance of constructor 'Insert' */
  323. tplelm new_Insert( p_lno, p_fname )
  324.  int p_lno;
  325.  string p_fname;
  326. {
  327.     register tplelm new;
  328.  
  329.     new = (tplelm) malloc( sizeof(*new) );
  330.     if( (char *)new == (char *)0 ){
  331.     FATAL( tm_outofmemory );
  332.     }
  333.     new->next = tplelmNIL;
  334.     new->tag = TAGInsert;
  335.     new->Insert.lno = p_lno;
  336.     new->Insert.fname = p_fname;
  337. #ifdef STAT
  338.     newcnt_Insert++;
  339. #endif
  340.     return (tplelm) new;
  341. }
  342.  
  343. /**********************************************************
  344.  *    fre_<type> and fre_<type>_list routines             *
  345.  **********************************************************/
  346.  
  347. #if defined(__STDC__) && __STDC__>0
  348. static void fre_tplelm( tplelm );
  349. #endif
  350.  
  351. /* free an element of type tplelm */
  352. static void fre_tplelm( e )
  353.  tplelm e;
  354. {
  355.     if( e == tplelmNIL ) return;
  356.     free( (char *) e );
  357. #ifdef STAT
  358.     switch( e->tag ){
  359.     case TAGPlain:
  360.         frecnt_Plain++;
  361.         break;
  362.  
  363.     case TAGForeach:
  364.         frecnt_Foreach++;
  365.         break;
  366.  
  367.     case TAGWhile:
  368.         frecnt_While++;
  369.         break;
  370.  
  371.     case TAGIf:
  372.         frecnt_If++;
  373.         break;
  374.  
  375.     case TAGSet:
  376.         frecnt_Set++;
  377.         break;
  378.  
  379.     case TAGAppend:
  380.         frecnt_Append++;
  381.         break;
  382.  
  383.     case TAGError:
  384.         frecnt_Error++;
  385.         break;
  386.  
  387.     case TAGExit:
  388.         frecnt_Exit++;
  389.         break;
  390.  
  391.     case TAGInclude:
  392.         frecnt_Include++;
  393.         break;
  394.  
  395.     case TAGCopy:
  396.         frecnt_Copy++;
  397.         break;
  398.  
  399.     case TAGInsert:
  400.         frecnt_Insert++;
  401.         break;
  402.  
  403.     default:
  404.         FATALTAG( e->tag );
  405.     }
  406. #endif
  407. }
  408.  
  409. #if defined(__STDC__) && __STDC__>0
  410. static void fre_tplelm_list( tplelm_list );
  411. #endif
  412.  
  413. /**********************************************************
  414.  *    rfre_<type> and rfre_<type>_list routines           *
  415.  **********************************************************/
  416.  
  417. #if defined(__STDC__) && __STDC__>0
  418. #else
  419. #endif
  420.  
  421.  
  422. /* Recursively free an element of type 'tplelm'
  423.    and all elements in it.
  424.  */
  425. void rfre_tplelm( e )
  426.  tplelm e;
  427. {
  428.     if( e == tplelmNIL ) return;
  429.     switch( e->tag ){
  430.     case TAGPlain:
  431.         rfre_int( e->Plain.lno );
  432.         rfre_string( e->Plain.plainline );
  433.         break;
  434.  
  435.     case TAGForeach:
  436.         rfre_int( e->Foreach.lno );
  437.         rfre_string( e->Foreach.felist );
  438.         rfre_tplelm_list( e->Foreach.felines );
  439.         break;
  440.  
  441.     case TAGWhile:
  442.         rfre_int( e->While.lno );
  443.         rfre_string( e->While.whilecond );
  444.         rfre_tplelm_list( e->While.whilelines );
  445.         break;
  446.  
  447.     case TAGIf:
  448.         rfre_int( e->If.lno );
  449.         rfre_string( e->If.ifcond );
  450.         rfre_tplelm_list( e->If.ifthen );
  451.         rfre_tplelm_list( e->If.ifelse );
  452.         break;
  453.  
  454.     case TAGSet:
  455.         rfre_int( e->Set.lno );
  456.         rfre_string( e->Set.setline );
  457.         break;
  458.  
  459.     case TAGAppend:
  460.         rfre_int( e->Append.lno );
  461.         rfre_string( e->Append.appline );
  462.         break;
  463.  
  464.     case TAGError:
  465.         rfre_int( e->Error.lno );
  466.         rfre_string( e->Error.errstr );
  467.         break;
  468.  
  469.     case TAGExit:
  470.         rfre_int( e->Exit.lno );
  471.         rfre_string( e->Exit.str );
  472.         break;
  473.  
  474.     case TAGInclude:
  475.         rfre_int( e->Include.lno );
  476.         rfre_string( e->Include.fname );
  477.         break;
  478.  
  479.     case TAGCopy:
  480.         rfre_int( e->Copy.lno );
  481.         rfre_string( e->Copy.fname );
  482.         break;
  483.  
  484.     case TAGInsert:
  485.         rfre_int( e->Insert.lno );
  486.         rfre_string( e->Insert.fname );
  487.         break;
  488.  
  489.     default:
  490.         FATALTAG( e->tag );
  491.     }
  492.     fre_tplelm( e );
  493. }
  494.  
  495. /* recursively free a list of elements of type tplelm */
  496. void rfre_tplelm_list( e )
  497.  register tplelm_list e;
  498. {
  499.     register tplelm n;
  500.  
  501.     while( e!=tplelmNIL ){
  502.     n = e->next;
  503.     rfre_tplelm( e );
  504.     e = n;
  505.     }
  506. }
  507.  
  508. /**********************************************************
  509.  *    app_<type>_list routines                            *
  510.  **********************************************************/
  511.  
  512. #if defined(__STDC__) && __STDC__>0
  513. #endif
  514.  
  515. /******************************************************
  516.  *    print_<type> and print_<type>_list routines     *
  517.  ******************************************************/
  518.  
  519. #if defined(__STDC__) && __STDC__>0
  520. #else
  521. #endif
  522.  
  523.  
  524. /*********************************************************
  525.  *    fprint_<type> and fprint_<type>_list routines      *
  526.  *********************************************************/
  527.  
  528. #if defined(__STDC__) && __STDC__>0
  529. #else
  530. #endif
  531.  
  532.  
  533. /*********************************************************
  534.  *    rdup_<type> and rdup_<type>_list routines          *
  535.  *********************************************************/
  536.  
  537. #if defined(__STDC__) && __STDC__>0
  538. #else
  539. #endif
  540.  
  541.  
  542. /*********************************************************
  543.  *    cmp_<type> and cmp_<type>_list routines            *
  544.  *********************************************************/
  545.  
  546. #if defined(__STDC__) && __STDC__>0
  547. #else
  548. #endif
  549.  
  550.  
  551. /*********************************************************
  552.  *    fscan_<type> and fscan_<type>_list routines        *
  553.  *********************************************************/
  554.  
  555. #if defined(__STDC__) && __STDC__>0
  556. #else
  557. #endif
  558.  
  559.  
  560. /*********************************************************
  561.  *    Statistics printing routines                       *
  562.  *********************************************************/
  563.  
  564. /* give statistics */
  565. void stat_tplelm( f )
  566.  FILE *f;
  567. {
  568. #ifdef STAT
  569.     fprintf(f,tm_allocfreed,"Plain",newcnt_Plain,frecnt_Plain,((newcnt_Plain==frecnt_Plain)? "": "<-"));
  570.     fprintf(f,tm_allocfreed,"Foreach",newcnt_Foreach,frecnt_Foreach,((newcnt_Foreach==frecnt_Foreach)? "": "<-"));
  571.     fprintf(f,tm_allocfreed,"While",newcnt_While,frecnt_While,((newcnt_While==frecnt_While)? "": "<-"));
  572.     fprintf(f,tm_allocfreed,"If",newcnt_If,frecnt_If,((newcnt_If==frecnt_If)? "": "<-"));
  573.     fprintf(f,tm_allocfreed,"Set",newcnt_Set,frecnt_Set,((newcnt_Set==frecnt_Set)? "": "<-"));
  574.     fprintf(f,tm_allocfreed,"Append",newcnt_Append,frecnt_Append,((newcnt_Append==frecnt_Append)? "": "<-"));
  575.     fprintf(f,tm_allocfreed,"Error",newcnt_Error,frecnt_Error,((newcnt_Error==frecnt_Error)? "": "<-"));
  576.     fprintf(f,tm_allocfreed,"Exit",newcnt_Exit,frecnt_Exit,((newcnt_Exit==frecnt_Exit)? "": "<-"));
  577.     fprintf(f,tm_allocfreed,"Include",newcnt_Include,frecnt_Include,((newcnt_Include==frecnt_Include)? "": "<-"));
  578.     fprintf(f,tm_allocfreed,"Copy",newcnt_Copy,frecnt_Copy,((newcnt_Copy==frecnt_Copy)? "": "<-"));
  579.     fprintf(f,tm_allocfreed,"Insert",newcnt_Insert,frecnt_Insert,((newcnt_Insert==frecnt_Insert)? "": "<-"));
  580. #else
  581.     f = f; /* to prevent 'f unused' from compiler and lint */
  582. #endif
  583. }
  584.  
  585. /* ---- end of /users/reeuwijk/esprit/lib/cllu.ct ---- */
  586.